home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / cmds / kgdb-4.5 / ds3100.md / gdb / RCS / mips_kgdb_remote.c,v < prev   
Encoding:
Text File  |  1992-11-09  |  45.2 KB  |  1,895 lines
  1. head     1.2;
  2. branch   ;
  3. access   ;
  4. symbols  ;
  5. locks    jhh:1.2; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.2
  10. date     92.11.08.21.34.36;  author jhh;  state Exp;
  11. branches ;
  12. next     1.1;
  13.  
  14. 1.1
  15. date     92.08.05.17.21.55;  author jhh;  state Exp;
  16. branches 1.1.1.1;
  17. next     ;
  18.  
  19. 1.1.1.1
  20. date     92.08.20.12.46.58;  author jhh;  state Exp;
  21. branches ;
  22. next     ;
  23.  
  24.  
  25. desc
  26. @@
  27.  
  28.  
  29. 1.2
  30. log
  31. @looks like Matt made a few changes -- jhh
  32. @
  33. text
  34. @/* Memory-access and commands for inferior process, for GDB.
  35.    Copyright (C)  1988 Free Software Foundation, Inc.
  36.  
  37. GDB is distributed in the hope that it will be useful, but WITHOUT ANY
  38. WARRANTY.  No author or distributor accepts responsibility to anyone
  39. for the consequences of using it or for whether it serves any
  40. particular purpose or works at all, unless he says so in writing.
  41. Refer to the GDB General Public License for full details.
  42.  
  43. Everyone is granted permission to copy, modify and redistribute GDB,
  44. but only under the conditions described in the GDB General Public
  45. License.  A copy of this license is supposed to have been given to you
  46. along with GDB so you can know your rights and responsibilities.  It
  47. should be in a file named COPYING.  Among other things, the copyright
  48. notice and this notice must be preserved on all copies.
  49.  
  50. In other words, go ahead and share GDB, but don't try to stop
  51. anyone else from sharing it farther.  Help stamp out software hoarding!
  52. */
  53. /*#define MACH_NUM_GPRS 32
  54. #define MACH_NUM_FPRS 32*/
  55. #include <stdio.h>
  56. #include <sprite.h>
  57. #include <signal.h>
  58. #include <sys/types.h>
  59. #include <sys/file.h>
  60. #include <errno.h>
  61. /*#include <kernel/ds3100.md/machConst.h>*/
  62. #include <kernel/machTypes.h>
  63. #include <kernel/dbg.h>
  64. #include <kernel/procTypes.h>
  65.  
  66. #include "defs.h"
  67. #include <sys/param.h>
  68. #include "frame.h"
  69. #include "inferior.h"
  70. #include "value.h"
  71. #include "expression.h"
  72. /*#include "wait.h"*/
  73. #include <sys/wait.h>
  74. #include "sprite.h"
  75. #include "target.h"
  76.  
  77. /*
  78.  * The data cache is just an array of characters.
  79.  */
  80. static char *dataCache;
  81.  
  82. /*
  83.  * There is information about kept about each cache block.
  84.  */
  85. typedef    struct {
  86.     int        version;    /* Version number of this cache block. */
  87.     char    *realAddr;    /* Actual address of data stored in the block.*/
  88. } CacheInfo;
  89. static CacheInfo    *cacheInfo;
  90. static int    currentVersion = 1;
  91.  
  92. /*
  93.  * Useful macros
  94.  * ERROR_NO_ATTACHED_HOST - Remote an error and abort if no host is
  95.  *                currently attached.
  96.  * MARK_DISCONNECTED - Mark a host a disconnected and free up state.
  97.  */
  98.  
  99. #define ERROR_NO_ATTACHED_HOST \
  100.     if (!hostName) error("No machine attached.");
  101.  
  102. #define MARK_DISCONNECTED  {     \
  103.     initialized = 0;          \
  104.     inferior_pid = 0;        \
  105.     hostName = (char *) 0;     \
  106.     free(dataCache);      \
  107.     free(cacheInfo);      \
  108.     }
  109.  
  110. extern struct target_ops remote_ops;    /* Forward decl */
  111. int remote_debugging = 0;
  112.  
  113. /*
  114.  * Hostname of attached remote hosts.  Error otherwise.
  115.  */
  116.  
  117. char *hostName;
  118.  
  119. static    int    initialized = 0; /* Set to true when remote connection is
  120.                   * initialized. */
  121.  
  122. /*
  123.  * Table mapping kernel exceptions into Unix signals.  
  124.  */
  125.  
  126. struct sig_mapping_struct {
  127.     char     *sig_name;    /* Print string for signal. */
  128.     int     dbgSig;     /* Boolean - A signal used by the debugger. */
  129.     int     unixSignal;     /* Unix signal equalient. */
  130. } sig_mapping[] =  {
  131. /* 0 */ { "Interrupt pending", 0, SIGILL },
  132. /* 1 */ { "TLB modified fault", 0, SIGSEGV },
  133. /* 2 */ { "TLB miss on load or ifetch", 0, SIGSEGV },
  134. /* 3 */ { "TLB miss on a store", 0, SIGSEGV },
  135. /* 4 */ { "Address error on a load or ifetch", 0, SIGBUS },
  136. /* 5 */ { "Address error on a store", 0, SIGBUS },
  137. /* 6 */ { "Bus error on an ifetch", 0, SIGBUS },
  138. /* 7 */ { "Bus error on a load or store", 0, SIGBUS },
  139. /* 8 */ { "System call", 0, SIGSYS },
  140. /* 9 */ { "Breakpoint",  1, SIGTRAP },
  141. /* 10 */ { "Reserved Instruction", 0, SIGILL },
  142. /* 11 */ { "Coprocessor Unusable",  0, SIGILL },
  143. /* 12 */ { "Arithmetic overflow",  0, SIGILL },
  144. /* 13 */ { "UNKNOWN EXCEPTION", 0, SIGSEGV },
  145. };
  146.  
  147. #define    NUM_SIG_MAPS    (sizeof(sig_mapping)/sizeof(sig_mapping[0]))
  148.  
  149.  
  150.  
  151. #define    PBUFSIZ    1024
  152.  
  153. /* Maximum number of bytes to read/write at once.  The value here
  154.    is chosen to fill up a packet (the headers account for the 32).  */
  155. #define MAXBUFBYTES ((PBUFSIZ-32)/2)
  156.  
  157.  
  158. /*
  159.  *----------------------------------------------------------------------
  160.  *
  161.  * Regnum_to_index --
  162.  *
  163.  *    Function mapping a gdb register number into an index.
  164.  *
  165.  * Results:
  166.  *    Index to Mach_State structure when treated as an array on ints.
  167.  *
  168.  * Side effects:
  169.  *    None.
  170.  *
  171.  *----------------------------------------------------------------------
  172.  */
  173. static int 
  174. Regnum_to_index(r) 
  175.     int    r;
  176. { 
  177.   Mach_RegState bud;
  178. #define    O(f)    ((int)&(bud.f)/sizeof(int))
  179.   if (r < 32) return O(regs[r]);
  180.   if (r < PC_REGNUM) return  O(fpRegs[r-32]);
  181.   if (r == PC_REGNUM) return O(pc);
  182.   if (r == HI_REGNUM) return O(mfhi);
  183.   if (r == LO_REGNUM) return O(mflo);
  184.   if (r == FCRCS_REGNUM) return O(fpStatusReg);
  185.   return -1;
  186. #undef O
  187. };
  188. int lastPid = -1;    /* Process ID of process being examined. -1
  189.                  * means process causing trap. */
  190.  
  191. /*
  192.  * The following variables are sued when using the core memory interface
  193.  * rather than active ethernet debugging.
  194.  */
  195. static int remoteCoreChan = -1;    /* Open file descriptor of core file. -1 
  196.                  * means no file open. */
  197. static char *remoteCoreFile;    /* Malloced name of core file. */
  198. static int remoteOffset;    /* Offset used to convert addresses to 
  199.                  * offsets into core file. */
  200. StopInfo    remoteStopInfo;    /* Current Dbg_StopInfo from core file. */
  201. static Dbg_DumpBounds remoteBounds;  /* Dump bounds from core file. */
  202.  
  203. /*
  204.  * IN_CORE_FILE - Returns TRUE if address is in the corefile.
  205.  */
  206. #define    IN_CORE_FILE(addr) ((addr) >= (CORE_ADDR) remoteBounds.kernelCodeStart\
  207.       && ((addr) < (CORE_ADDR) remoteBounds.fileCacheStart + \
  208.                           remoteBounds.fileCacheSize))
  209.  
  210. /*
  211.  *----------------------------------------------------------------------
  212.  *
  213.  * remote_core_file_command --
  214.  *
  215.  *    kgdb.sun4 core_file command.
  216.  *
  217.  * Results:
  218.  *    None.
  219.  *
  220.  * Side effects:
  221.  *    None.
  222.  *
  223.  *----------------------------------------------------------------------
  224.  */
  225.  
  226. void
  227. remote_core_file_command (filename, from_tty)
  228.      char *filename;
  229.      int from_tty;
  230. {
  231.   /* Discard all vestiges of any previous core file
  232.      and mark data and stack spaces as empty.  */
  233.  
  234.   if (remoteCoreFile)
  235.     free (remoteCoreFile);
  236.   remoteCoreFile = 0;
  237.  
  238.   if (remoteCoreChan >= 0)
  239.     close (remoteCoreChan);
  240.   remoteCoreChan = -1;
  241.   if (filename == 0) {
  242.     printf ("Corefile cleared.\n");
  243.     return;
  244.   }
  245.  
  246.   filename = tilde_expand (filename);
  247.   make_cleanup (free, filename);
  248.  
  249.   remoteCoreChan = open (filename, O_RDONLY, 0);
  250.   if (remoteCoreChan < 0)
  251.     perror_with_name (filename);
  252.  
  253.   {
  254.     /*
  255.      * Read the StopInfo and bounds and start the debugging session.
  256.      */
  257.     int val;
  258.     val = myread (remoteCoreChan, &remoteStopInfo, sizeof remoteStopInfo);
  259.     if (val < 0)
  260.       perror_with_name (filename);
  261.     val = myread (remoteCoreChan, &remoteBounds, sizeof remoteBounds);
  262.     if (val < 0)
  263.       perror_with_name (filename);
  264.     remote_debugging = 1;
  265.     remoteOffset = remoteBounds.kernelCodeStart - sizeof(remoteStopInfo) -
  266.             sizeof(remoteBounds);
  267.     start_remote();
  268.   }
  269. }
  270.  
  271.  
  272. /* Open a connection to a remote debugger.
  273.    NAME is the filename used for communication.  */
  274.  
  275. void
  276. remote_open (name, from_tty)
  277.      char *name;
  278.      int from_tty;
  279. {
  280.   if (remoteCoreChan >= 0) {
  281.       error("Can't attach a machine when using a corefile\n");
  282.       return;
  283.   }
  284.  
  285.   hostName = savestring(name,strlen(name));
  286.   if (from_tty)
  287.     printf ("Remote debugging using %s\n", name);
  288.   push_target (&remote_ops);
  289.   remote_debugging = 1;
  290.   start_remote ();
  291. }
  292.  
  293. char *
  294. remote_version()
  295. {
  296.   static char    version[1024];
  297.   
  298.   ERROR_NO_ATTACHED_HOST;
  299.   Kdbx_Trace(DBG_GET_VERSION_STRING, 0, version, 1024);
  300.   return version;
  301. }
  302.  
  303.  
  304.  
  305. /* Tell the remote machine to resume.  */
  306.  
  307. int     step_addr, step_addr_contents[2];
  308.  
  309. void
  310. remote_resume (step, signal)
  311.      int step, signal;
  312. {
  313.   
  314.   if (signal)
  315.     error ("Can't send signals to a remote system.");
  316.   ERROR_NO_ATTACHED_HOST;
  317.   step_addr = -2;
  318.   if (step) {
  319.     if (Kdbx_Trace( DBG_SINGLESTEP, 0, 0, sizeof(int)) < 0) {
  320.       error("error trying to continue process\n");
  321.     }
  322.   } else {
  323.     if (Kdbx_Trace( DBG_CONTINUE, 0, 0, sizeof(int)) < 0) {
  324.       error("error trying to continue process\n");
  325.     }
  326.   }
  327.   
  328. }
  329.  
  330. /* Wait until the remote machine stops, then return,
  331.    storing status in STATUS just as `wait' would.  */
  332.  
  333. int
  334. remote_wait (status)
  335.      union wait *status;
  336. {
  337.   StopInfo    stopInfo;
  338.   int        cause;
  339.   int    text_size;
  340.   extern CORE_ADDR text_start, text_end;
  341. #if 0
  342.   if (remoteCoreChan >= 0) {
  343.     /*
  344.      * Debugging using core file, just set text_{start, end} and
  345.      * returned stopped signal.
  346.      */
  347.     status->w_status = 0;
  348.     status->w_stopval = WSTOPPED;
  349.     cause = remoteStopInfo.trapType;
  350.     status->w_stopsig = sig_mapping[cause].unixSignal;
  351.     if ((lastPid == -1) && !sig_mapping[cause].dbgSig) { 
  352.       printf("Kernel returns with signal (%d) %s\n", cause,
  353.          sig_mapping[trap].sig_name);
  354.     }
  355.     text_start = remoteBounds.kernelCodeStart;
  356.     text_end = remoteBounds.kernelCodeStart + remoteBounds.kernelCodeSize;
  357.     return status->w_stopsig;
  358.   }
  359. #endif
  360.   ERROR_NO_ATTACHED_HOST;
  361.   
  362.   if (Kdbx_Trace(DBG_GET_STOP_INFO, (char *) 0, (char *)&stopInfo,
  363.          sizeof(stopInfo)) != 0) {
  364.     error("Can't get stop info\n");
  365.   }
  366. #if 0
  367.   if (Kdbx_Trace(DBG_GET_DUMP_BOUNDS, (char *) 0, (char *)&remoteBounds,
  368.          sizeof(remoteBounds)) != 0) {
  369.     error("Can't get dump bounds\n");
  370.   }
  371. #endif
  372.   status->w_status = 0;
  373.   status->w_stopval = WSTOPPED;
  374.   cause = remoteStopInfo.trapType;
  375.   status->w_stopsig = sig_mapping[cause].unixSignal;
  376.   if ((lastPid != -1) && !sig_mapping[cause].dbgSig) { 
  377.     printf("Kernel returns with signal (%d) %s\n",stopInfo.trapType,
  378.        sig_mapping[cause].sig_name);
  379.   }
  380.  
  381.   text_start = stopInfo.codeStart;
  382. #if 0  
  383.   text_size = remoteBounds.kernelCodeSize;
  384. #else
  385.   text_size = 0xc0000000 - text_start;
  386. #endif
  387.   text_end = text_start+text_size;
  388.   return status->w_stopsig;
  389. }
  390.  
  391. /* Read the remote registers into the block REGS.  */
  392. #define FIRST_LOCAL_REGNUM    16
  393. void
  394. remote_fetch_registers (regno)
  395.      int regno;
  396. {
  397.   StopInfo    stopInfo;
  398.   char regs[REGISTER_BYTES];
  399.   int i;
  400. #if 0
  401.   if (remoteCoreChan >= 0) {
  402.     
  403.     bcopy(remoteStopInfo.regs.globals,regs,4*8);
  404.     bcopy(remoteStopInfo.regs.ins,regs+4*8,4*8);
  405.     ((int *)regs)[Y_REGNUM] = remoteStopInfo.regs.y; 
  406.     ((int *)regs)[PS_REGNUM] = remoteStopInfo.regs.curPsr; 
  407.     ((int *)regs)[PC_REGNUM] = remoteStopInfo.regs.pc; 
  408.     ((int *)regs)[NPC_REGNUM] = remoteStopInfo.regs.nextPc; 
  409.     remote_read_bytes(remoteStopInfo.regs.ins[6], 
  410.               ((int *) regs) + FIRST_LOCAL_REGNUM,4*16);
  411.     return;
  412.   }
  413. #endif
  414.   ERROR_NO_ATTACHED_HOST;
  415.   Kdbx_Trace(DBG_GET_STOP_INFO, (char *) 0, (char *)&stopInfo,
  416.          sizeof(stopInfo));
  417.   bcopy(stopInfo.regs.regs,regs,4*32);
  418.   bcopy(stopInfo.regs.fpRegs,regs+4*32,4*32);
  419.   ((int *)regs)[PC_REGNUM] = (int) stopInfo.regs.pc; 
  420.   ((int *)regs)[FP_REGNUM] = (int) stopInfo.regs.regs[29]; 
  421.   ((int *)regs)[SP_REGNUM] = (int) stopInfo.regs.regs[29]; 
  422.   ((int *)regs)[HI_REGNUM] = stopInfo.regs.mfhi; 
  423.   ((int *)regs)[LO_REGNUM] = stopInfo.regs.mflo; 
  424.   ((int *)regs)[FCRCS_REGNUM] = stopInfo.regs.fpStatusReg; 
  425.   for (i = 0; i < NUM_REGS; i++)
  426.     supply_register (i, ®s[REGISTER_BYTE(i)]);
  427. }
  428.  
  429.  
  430. int
  431. remote_attach(pid)
  432.      int    pid;
  433. {
  434.   int    status;
  435.   struct expression *expr;
  436.   register struct cleanup *old_chain;
  437.   register value val;
  438.   int    machRegStateAddr;
  439.   Proc_ControlBlock    *procPtr;
  440.   Mach_RegState machRegState;
  441.   char    exp[128];
  442.   
  443.   ERROR_NO_ATTACHED_HOST;
  444.   if (pid != lastPid) {
  445.     Kdbx_Trace(DBG_SET_PID, &pid, 0,sizeof(int));
  446.     lastPid = pid;
  447.   }
  448.   start_remote();
  449.   return 1;
  450. }
  451.  
  452. void
  453. remote_detach(args, from_tty)
  454.      char *args;
  455.      int from_tty;
  456. {
  457.   int cur_pc;
  458.   
  459.   ERROR_NO_ATTACHED_HOST;
  460.   cur_pc = read_pc();
  461.   if (args) 
  462.     Kdbx_Trace(DBG_DETACH, &cur_pc, 0, sizeof(int));
  463.   remote_clean_up();
  464.   pop_target ();
  465.   remote_debugging = 0;
  466.   if (from_tty)
  467.     printf("Ending remote debugging.\n");
  468. }
  469.  
  470.  
  471.  
  472. /* Read a word from remote address ADDR and return it.
  473.    This goes through the data cache.  */
  474.  
  475. int
  476. remote_fetch_word (addr)
  477.      CORE_ADDR addr;
  478. {
  479.   
  480.   int buffer;
  481.   extern CORE_ADDR text_start, text_end;
  482.   
  483.   ERROR_NO_ATTACHED_HOST;
  484.   if (addr >= text_start && addr < text_end)
  485.     {
  486.       if (Kdbx_Trace(DBG_INST_READ, addr, &buffer, sizeof(int)) != 0) {
  487.     errno = EIO;
  488.     return 0;
  489.       }
  490.       return buffer;
  491.     }
  492.   if (Kdbx_Trace(DBG_DATA_READ, addr, &buffer, sizeof(int)) != 0) {
  493.     errno = EIO;
  494.     return 0;
  495.   }
  496.   return buffer;
  497. }
  498.  
  499. /* Write a word WORD into remote address ADDR.
  500.    This goes through the data cache.  */
  501.  
  502. void
  503. remote_store_word (addr, word)
  504.      CORE_ADDR addr;
  505.      int word;
  506. {
  507.   extern CORE_ADDR text_start, text_end;
  508.   ERROR_NO_ATTACHED_HOST;
  509.   if (addr >= text_start && addr < text_end)
  510.     {
  511.       if (Kdbx_Trace(DBG_INST_WRITE, &word, addr, sizeof(word))!= 0) {
  512.     errno = EIO;
  513.       }
  514.       return;
  515.     }
  516.   if ( Kdbx_Trace(DBG_DATA_WRITE,  &word, addr, sizeof(word)) != 0) {
  517.     errno = EIO;
  518.   }
  519.   return;
  520. }
  521.  
  522. /* Write memory data directly to the remote machine.
  523.    This does not inform the data cache; the data cache uses this.
  524.    MEMADDR is the address in the remote memory space.
  525.    MYADDR is the address of the buffer in our space.
  526.    LEN is the number of bytes.  */
  527.  
  528. int
  529. remote_write_bytes (memaddr, myaddr, len)
  530.      CORE_ADDR memaddr;
  531.      char *myaddr;
  532.      int len;
  533. {
  534.   extern CORE_ADDR text_start, text_end;
  535.   ERROR_NO_ATTACHED_HOST;
  536.   if (memaddr >= text_start && memaddr < text_end)
  537.     {
  538.       return Kdbx_Trace(DBG_INST_WRITE, myaddr, memaddr, len);
  539.      }
  540.   return Kdbx_Trace(DBG_DATA_WRITE,  myaddr, memaddr, len);
  541. }
  542.  
  543. /* Read memory data directly from the remote machine.
  544.    This does not use the data cache; the data cache uses this.
  545.    MEMADDR is the address in the remote memory space.
  546.    MYADDR is the address of the buffer in our space.
  547.    LEN is the number of bytes.  */
  548.  
  549. int
  550. remote_read_bytes (memaddr, myaddr, len)
  551.      CORE_ADDR memaddr;
  552.      char *myaddr;
  553.      int len;
  554. {
  555.   int err;
  556.   ERROR_NO_ATTACHED_HOST;
  557.   return Kdbx_Trace(DBG_DATA_READ, memaddr, myaddr, len);
  558. }
  559.  
  560. #if 0
  561. /* Read LEN bytes from inferior memory at MEMADDR.  Put the result
  562.    at debugger address MYADDR.  Returns errno value.  */
  563. int
  564. remote_read_inferior_memory(memaddr, myaddr, len)
  565.      CORE_ADDR memaddr;
  566.      char *myaddr;
  567.      int len;
  568. {
  569.   int xfersize, err;
  570.   while (len > 0)
  571.     {
  572.       if (len > MAXBUFBYTES)
  573.     xfersize = MAXBUFBYTES;
  574.       else
  575.     xfersize = len;
  576.       
  577.       err = remote_read_bytes (memaddr, myaddr, xfersize);
  578.       if (err != 0) 
  579.     return err;
  580.       memaddr += xfersize;
  581.       myaddr  += xfersize;
  582.       len     -= xfersize;
  583.     }
  584.   return 0; /* no error */
  585. }
  586.  
  587. /* Copy LEN bytes of data from debugger memory at MYADDR
  588.    to inferior's memory at MEMADDR.  Returns errno value.  */
  589. int
  590. remote_write_inferior_memory (memaddr, myaddr, len)
  591.      CORE_ADDR memaddr;
  592.      char *myaddr;
  593.      int len;
  594. {
  595.   int xfersize;
  596.   int err;
  597.   while (len > 0)
  598.     {
  599.       if (len > MAXBUFBYTES)
  600.     xfersize = MAXBUFBYTES;
  601.       else
  602.     xfersize = len;
  603.       
  604.       err = remote_write_bytes(memaddr, myaddr, xfersize);
  605.       if (err != 0) {
  606.     return err;
  607.       }
  608.       
  609.       memaddr += xfersize;
  610.       myaddr  += xfersize;
  611.       len     -= xfersize;
  612.     }
  613.   return 0; /* no error */
  614. }
  615. #endif /* 0 */
  616.  
  617. /* Prepare to store registers.  Since we send them all, we have to
  618.    read out the ones we don't want to change first.  */
  619.  
  620. void 
  621. remote_prepare_to_store ()
  622. {
  623.   remote_fetch_registers (-1);
  624. }
  625.  
  626. /* Store the remote registers from the contents of the block REGS.  */
  627.  
  628. void
  629. remote_store_registers (regs,regno)
  630.      char *regs;
  631.      int    regno;
  632. {
  633.   int    i;
  634.   
  635.   ERROR_NO_ATTACHED_HOST;
  636.   if (regno < 0) { 
  637.     for (i = 0; i < 32 + 32; i++) {
  638.       Kdbx_Trace(DBG_WRITE_REG, &(((int *)regs)[i]),
  639.          Regnum_to_index(i),sizeof(int));
  640.     }    
  641.     Kdbx_Trace(DBG_WRITE_REG, ((int *)regs)+PC_REGNUM,
  642.            Regnum_to_index(PC_REGNUM),sizeof(int));
  643.     Kdbx_Trace(DBG_WRITE_REG, ((int *)regs)+HI_REGNUM,
  644.            Regnum_to_index(HI_REGNUM),sizeof(int));
  645.     Kdbx_Trace(DBG_WRITE_REG, ((int *)regs)+LO_REGNUM,
  646.            Regnum_to_index(LO_REGNUM),sizeof(int));
  647.     Kdbx_Trace(DBG_WRITE_REG, ((int *)regs)+FCRCS_REGNUM,
  648.            Regnum_to_index(FCRCS_REGNUM),sizeof(int));
  649.   } else {
  650.     int    ind = Regnum_to_index(regno);
  651.     if (ind >= 0) 
  652.       Kdbx_Trace(DBG_WRITE_REG, ((int *)regs)+regno,ind,sizeof(int));
  653.     else
  654.       remote_write_bytes(((int *) regs)[SP_REGNUM], 
  655.              ((int *) regs) + regno,4);
  656.   }
  657. }
  658.  
  659. /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
  660.    to or from debugger address MYADDR.  Write to inferior if SHOULD_WRITE is
  661.    nonzero.  Returns length of data written or read; 0 for error.  */
  662.  
  663. /* ARGSUSED */
  664. int
  665. remote_xfer_memory(memaddr, myaddr, len, should_write, target)
  666.      CORE_ADDR memaddr;
  667.      char *myaddr;
  668.      int len;
  669.      int should_write;
  670.      struct target_ops *target;            /* ignored */
  671. {
  672.   int origlen = len;
  673.   int xfersize;
  674.   while (len > 0)
  675.     {
  676.       if (len > MAXBUFBYTES)
  677.     xfersize = MAXBUFBYTES;
  678.       else
  679.     xfersize = len;
  680.       
  681.       if (should_write)
  682.     remote_write_bytes(memaddr, myaddr, xfersize);
  683.       else
  684.     remote_read_bytes (memaddr, myaddr, xfersize);
  685.       memaddr += xfersize;
  686.       myaddr  += xfersize;
  687.       len     -= xfersize;
  688.     }
  689.   return origlen; /* no error possible */
  690. }
  691.  
  692. /* 
  693.  * Call a remote function.
  694.  */
  695. call_remote_function(funaddr,nargs,numBytes,argBuffer)
  696.      CORE_ADDR funaddr;
  697.      int        nargs;
  698.      int        numBytes;
  699.      char    *argBuffer;
  700. {
  701.   int    returnValue;
  702.   ERROR_NO_ATTACHED_HOST;
  703.   Kdbx_Trace(DBG_BEGIN_CALL, (char *)0, (char *)0, 0);  
  704.   returnValue = Kdbx_Trace(DBG_CALL_FUNCTION,argBuffer,funaddr,numBytes);
  705.   Kdbx_Trace(DBG_END_CALL, (char *)0, (char *)0, 0);       
  706.   return returnValue;
  707. }
  708.  
  709. void
  710. remote_close(quitting)
  711.      int quitting;
  712. {
  713. }
  714.  
  715. remote_clean_up()
  716. {
  717.   MARK_DISCONNECTED;
  718. }
  719.  
  720.  
  721. read_kmem(memaddr, myaddr, len)
  722.      char *memaddr;
  723.      char *myaddr;
  724.      int      len;
  725. {
  726.   static int fd = -1;
  727.   int count;
  728.   
  729.   if (fd < 0) { 
  730.     char template[100];
  731.     /*
  732.      * Open a temp file to write counters to. We unlink the file so it will
  733.      * disappear when we exit.
  734.      */
  735.     strcpy(template, "/tmp/kgdbXXXXXXXX");
  736.     fd = mkstemp(template);
  737.     if (fd < 0) {
  738.       error("open kmem tmp file");
  739.     }
  740.     (void) unlink(template);
  741.   }
  742.   if (lseek(fd, 0, L_SET) < 0) {
  743.     error("lseek kmem file");
  744.   }
  745.   count = write(fd, memaddr, len);
  746.   if (count != len) {
  747.     return EIO;
  748.   }
  749.   
  750.   /*
  751.    * Rewind the file and read the counters from it.
  752.    */
  753.   count = lseek(fd, 0, L_SET);
  754.   if (count >= 0) {
  755.     count = read(fd, myaddr, len);
  756.   }
  757.   if (count != len) {
  758.     return EIO;
  759.   }
  760.   return 0;
  761. }
  762.  
  763. void
  764. remote_reboot (args)
  765.      char *args;
  766. {
  767.   
  768.   ERROR_NO_ATTACHED_HOST;
  769.   if (!args)
  770.     args = "";
  771.   
  772.   Kdbx_Trace(DBG_REBOOT, args, NULL, strlen(args));
  773. }
  774.  
  775. void
  776. remote_files_info ()
  777. {
  778.   printf ("remote files info missing here.  FIXME.\n");
  779. }
  780.  
  781. struct target_ops remote_ops = {
  782.   "remote", "Remote serial target in gdb-specific protocol",
  783.   "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
  784.  Specify the serial device it is connected to (e.g. /dev/ttya).", 
  785.     remote_open, 
  786.     remote_close, 
  787.     remote_attach,
  788.     remote_detach, 
  789.     remote_resume, 
  790.     remote_wait, /* attach */ 
  791.     remote_fetch_registers, 
  792.     remote_store_registers, 
  793.     remote_prepare_to_store, 
  794.     0, 0, /* conv_from, conv_to */ 
  795.     remote_xfer_memory, 
  796.     remote_files_info, 
  797.     0, 0, /* insert and remove breakpoint */
  798.     0, 0, 0, 0, 0, /* Terminal crud */ 
  799.     remote_detach, /* kill */ 
  800.     0, /* load */ 
  801.     0, /* lookup_symbol */ 
  802.     0, 0, /* create_inferior FIXME, mourn_inferior FIXME */ 
  803.     process_stratum, 0, /* next */ 
  804.     1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */ 
  805.     0, 0, /* Section pointers */ 
  806.     OPS_MAGIC, /* Always the last thing */
  807.   };
  808.  
  809. void
  810. _initialize_remote ()
  811. {
  812.   add_target (&remote_ops);
  813. }
  814.  
  815. #include <sys/types.h>
  816. #include <sys/socket.h>
  817. #include <sys/time.h>
  818. #include <netinet/in.h>
  819. #include <netdb.h>
  820. #include <sgtty.h>
  821.  
  822. /*
  823.  * Direct mapped cache of data and code.   The cache is flushed after every
  824.  * step and continue by incrementing the version number.  Flushing code
  825.  * isn't necessary but since kdbx already has an internal code cache it
  826.  * doesn't hurt and makes life easier.
  827.  */
  828. static    int    cacheBlockSize = -1;
  829. static    int    cacheBlockShift = -1;
  830. static    int    cacheSize = 128 * 1024;
  831. #define    CACHE_BLOCK_MASK     (cacheSize / cacheBlockSize - 1)
  832. #define    CACHE_BLOCK_OFFSET_MASK    (cacheBlockSize - 1)
  833. #define    NUM_CACHE_BLOCKS    (cacheSize >> cacheBlockShift)
  834. #define    CACHE_OFFSET_MASK    (cacheSize - 1)
  835. #define    GET_CACHE_BLOCK(address) (((unsigned int) address) >> cacheBlockShift)
  836.  
  837. /*
  838.  * Stuff for the serial port.
  839.  */
  840. static    int    kernChannel = 0;
  841.  
  842.  
  843. /*
  844.  * Message buffers.
  845.  */
  846. static Dbg_Msg    msg;
  847. static int    msgSize;
  848. #define    REPLY_BUFFER_SIZE    16384
  849. static    char    replyBuffer[REPLY_BUFFER_SIZE];
  850. static    char    requestBuffer[DBG_MAX_REQUEST_SIZE];
  851. /*
  852.  * The starting message number is set to 0x40000000 so that the debugger
  853.  * stub can differentiate between messages from kgdb and kdbx.  Once
  854.  * kdbx is gone the msgNum can be initialized to 0.
  855.  */
  856. #ifdef KDBX
  857. #define FIRST_MSG 0x40000000
  858. static    int    msgNum = FIRST_MSG;
  859. #else
  860. static    int    msgNum = 0;
  861. #endif
  862.  
  863. static void    RecvReply();
  864.  
  865. static    struct sockaddr_in    remote;
  866. static    int            kdbxTimeout = 1;
  867. static    int            netSocket;
  868.  
  869.  
  870. /*
  871.  *----------------------------------------------------------------------
  872.  *
  873.  * CreateSocket --
  874.  *
  875.  *    Creates a UDP socket connected to the Sprite host's kernel 
  876.  *    debugger port.
  877.  *
  878.  * Results:
  879.  *    The stream ID of the socket.
  880.  *
  881.  * Side effects:
  882.  *    None.
  883.  *
  884.  *----------------------------------------------------------------------
  885.  */
  886. static int
  887. CreateSocket(spriteHostName)
  888.     char    *spriteHostName;
  889. {
  890.     int            socketID;
  891.     struct hostent     *hostPtr;
  892.  
  893.     hostPtr = gethostbyname(spriteHostName);
  894.     if (hostPtr == (struct hostent *) NULL) {
  895.     error("CreateSocket: unknown host %s\n", spriteHostName);
  896.     }
  897.     if (hostPtr->h_addrtype != AF_INET) {
  898.     error("CreateSocket: bad address type for host %s\n", 
  899.         spriteHostName);
  900.     }
  901.  
  902.     socketID = socket(AF_INET, SOCK_DGRAM, 0);
  903.     if (socketID < 0) {
  904.     perror_with_name("CreateSocket: socket");
  905.     }
  906.  
  907.     bzero((Address)&remote, sizeof(remote));
  908.     bcopy(hostPtr->h_addr, (Address)&remote.sin_addr, hostPtr->h_length);
  909.     remote.sin_port = htons(DBG_UDP_PORT);
  910.     remote.sin_family = AF_INET;
  911.  
  912.     if (connect(socketID, (struct sockaddr *) &remote, sizeof(remote)) < 0) {
  913.     perror_with_name("CreateSocket: connect");
  914.     }
  915.  
  916.     return(socketID);
  917. }
  918.  
  919.  
  920. /*
  921.  * ----------------------------------------------------------------------------
  922.  *
  923.  *  StartDebugger --
  924.  *
  925.  *     Start off a new conversation with the debugger.
  926.  *
  927.  * Results:
  928.  *     None.
  929.  *
  930.  * Side effects:
  931.  *     Setup r network socket.
  932.  * ----------------------------------------------------------------------------
  933.  */
  934. static void
  935. StartDebugger()
  936. {
  937.         char    *host = hostName;
  938.     hostName = (char *) 0;
  939.     netSocket = CreateSocket(host);
  940.     hostName = host;
  941. }
  942.  
  943.  
  944. /*
  945.  * ----------------------------------------------------------------------------
  946.  *
  947.  *  SendRequest --
  948.  *
  949.  *     Send a request message to the kernel.
  950.  *
  951.  * Results:
  952.  *     None.
  953.  *
  954.  * Side effects:
  955.  *     None.
  956.  * ----------------------------------------------------------------------------
  957.  */
  958. static void
  959. SendRequest(numBytes, newRequest)
  960.     int        numBytes;
  961.     Boolean    newRequest;
  962. {
  963.      {
  964.     Dbg_Opcode    opcode;
  965.  
  966.     msgSize = numBytes;
  967.     if (newRequest) {
  968.         msgNum++;
  969.     }
  970.     *(int *)requestBuffer = msgNum;
  971.     bcopy(&msg, requestBuffer + 4, numBytes);
  972.     if (write(netSocket, requestBuffer, numBytes + 4) < numBytes + 4) {
  973.       MARK_DISCONNECTED;
  974.       perror_with_name("SendRequest: Couldn't write to the kernel socket\n");
  975.       return;
  976.     }
  977.     if (newRequest) {
  978.       opcode = (Dbg_Opcode) msg.opcode;
  979.       if (opcode == DBG_DETACH || opcode == DBG_CONTINUE ||
  980.           opcode == DBG_SINGLESTEP || opcode == DBG_DIVERT_SYSLOG || 
  981.           opcode == DBG_BEGIN_CALL || 
  982.           opcode == DBG_WRITE_REG || opcode == DBG_SET_PID) {
  983.         int    dummy;
  984.         /*
  985.          * Wait for explicit acknowledgments of these packets.
  986.          */
  987.         RecvReply(opcode, 4, &dummy, NULL, 1);
  988.       }
  989.     }
  990.     }
  991. }
  992.  
  993.  
  994. /*
  995.  * ----------------------------------------------------------------------------
  996.  *
  997.  *  RecvReply --
  998.  *
  999.  *     Receive a reply from the kernel.
  1000.  *
  1001.  * Results:
  1002.  *     None.
  1003.  *
  1004.  * Side effects:
  1005.  *     None.
  1006.  * ----------------------------------------------------------------------------
  1007.  */
  1008. static void
  1009. RecvReply(opcode, numBytes, destAddr, readStatusPtr, timeout)
  1010.     Dbg_Opcode    opcode;
  1011.     int        numBytes;
  1012.     char    *destAddr;
  1013.     int    *readStatusPtr;
  1014.     int    timeout;
  1015. {
  1016.     int        status;
  1017.     int     resendRequest = 0;
  1018.  
  1019.     if (numBytes + 8 > REPLY_BUFFER_SIZE) {
  1020.     fprintf(stderr,"numBytes <%d> > REPLY_BUFFER_SIZE <%d>\n",
  1021.             numBytes + 8, REPLY_BUFFER_SIZE);
  1022.     abort();
  1023.     }
  1024.      {
  1025.     int        readMask;
  1026.     struct    timeval    interval;
  1027.     int        bytesRead;
  1028.  
  1029.     interval.tv_sec = kdbxTimeout;
  1030.     interval.tv_usec = 0;
  1031.     do {
  1032.         if (timeout) {
  1033.         int    numTimeouts;
  1034.  
  1035.         numTimeouts = 0;
  1036.         /*
  1037.          * Loop timing out and sending packets until a new packet
  1038.          * has arrived.
  1039.          */
  1040.         do {
  1041.             if (!resendRequest) { 
  1042.             readMask = 1 << netSocket;
  1043.             status = select(32, &readMask, NULL, NULL, &interval);
  1044.             } else {
  1045.             status = 0;
  1046.             resendRequest = 0;
  1047.             }
  1048.             if (status == 1) {
  1049.             break;
  1050.             } else if (status == -1) {
  1051.                 MARK_DISCONNECTED;
  1052.             perror_with_name("RecvReply: Couldn't select on socket.\n");
  1053.             } else if (status == 0) {
  1054.             SendRequest(msgSize, 0);
  1055.             numTimeouts++;
  1056.             if (numTimeouts % 10 == 0) {
  1057.                 fprintf(stderr, 
  1058.                     "Timing out and resending to host %s\n",
  1059.                     hostName);
  1060.                 fflush(stderr);
  1061.                 QUIT;
  1062.             }
  1063.             }
  1064.         } while (1);
  1065.         }
  1066.         if (opcode == DBG_DATA_READ || opcode == DBG_INST_READ ||
  1067.         opcode == DBG_GET_VERSION_STRING) {
  1068.         /*
  1069.          * Data and instruction reads return variable size packets.
  1070.          * The first two ints are message number and status.  If
  1071.          * the status is OK then the data follows.
  1072.          */
  1073.         immediate_quit++;
  1074.         bytesRead = read(netSocket, replyBuffer, numBytes + 8);
  1075.         immediate_quit--;
  1076.         if (bytesRead < 0) {
  1077.             MARK_DISCONNECTED;
  1078.             perror_with_name("RecvReply: Error reading socket.");
  1079.         }
  1080.         /*
  1081.          * Check message number before the size because this could
  1082.          * be an old packet.
  1083.          */
  1084.         if (*(int *)replyBuffer != msgNum) {
  1085. #ifdef KDBX
  1086.             printf("RecvReply: Old message number = %d, expecting %d\n",
  1087.                 *(int *)replyBuffer - FIRST_MSG, 
  1088.                 msgNum - FIRST_MSG);
  1089. #else
  1090.             printf("RecvReply: Old message number = %d, expecting %d\n",
  1091.                 *(int *)replyBuffer, msgNum);
  1092. #endif
  1093.             fflush(stdout);
  1094.             resendRequest = 1;
  1095.             continue;
  1096.         }
  1097.         if (bytesRead == 8) {
  1098.             /*
  1099.              * Only 8 bytes so the read failed and there is no data.
  1100.              */
  1101.             *readStatusPtr = 0;
  1102.             return;
  1103.         }
  1104.             if (opcode == DBG_GET_VERSION_STRING) {
  1105.              strncpy(destAddr, (char *)(replyBuffer + 4),numBytes);
  1106.              return;
  1107.         }
  1108.         if (bytesRead != numBytes + 8) {
  1109.             printf("RecvReply: Short read (1): op=%d exp=%d read=%d",
  1110.                 opcode, numBytes + 4, bytesRead);
  1111.             continue;
  1112.         }
  1113.         *readStatusPtr = 1;
  1114.         bcopy(replyBuffer + 8, destAddr, numBytes);
  1115.         return;
  1116.         } else if (opcode == DBG_END_CALL) {
  1117.         int    length;
  1118.         /*
  1119.          * End call returns a variable size packet that contains
  1120.          * the result of the call. The format of the message is 
  1121.          * message number, length, data.
  1122.          */
  1123.         immediate_quit++;
  1124.         bytesRead = read(netSocket, replyBuffer, REPLY_BUFFER_SIZE);
  1125.         immediate_quit--;
  1126.         if (bytesRead < 0) {
  1127.             MARK_DISCONNECTED;
  1128.             perror_with_name("RecvReply: Error reading socket.");
  1129.         }
  1130.         /*
  1131.          * Check message number before the size because this could
  1132.          * be an old packet.
  1133.          */
  1134.         if (*(int *)replyBuffer != msgNum) {
  1135. #ifdef KDBX
  1136.             printf("RecvReply: Old message number = %d, expecting %d\n",
  1137.                 *(int *)replyBuffer - FIRST_MSG, 
  1138.                 msgNum - FIRST_MSG);
  1139. #else
  1140.             printf("RecvReply: Old message number = %d, expecting %d\n",
  1141.                 *(int *)replyBuffer, msgNum);
  1142. #endif
  1143.             fflush(stdout);
  1144.             resendRequest = 1;
  1145.             continue;
  1146.         }
  1147.         length = *( int *)(replyBuffer + 4);
  1148.         if (bytesRead - 8 != length) {
  1149.             fprintf(stderr, "RecvReply: Short read for syslog data\n");
  1150.             fprintf(stderr, "RecvReply: Read %d, length %d\n", 
  1151.             bytesRead - 8, length);
  1152.             fflush(stderr);
  1153.             length = bytesRead - 8;
  1154.         }
  1155.         if (length <= 0) {
  1156.             /*
  1157.              * No data.
  1158.              */
  1159.             *readStatusPtr = 0;
  1160.             return;
  1161.         }
  1162.         /*
  1163.          * Dump out the buffer.
  1164.          */
  1165.         write(1, replyBuffer + 8, length);
  1166.         *readStatusPtr = 1;
  1167.         return;
  1168.         } else {
  1169.         /*
  1170.          * Normal request so just read in the message which includes
  1171.          * the message number.
  1172.          */
  1173.         immediate_quit++;
  1174.         bytesRead = read(netSocket, replyBuffer, numBytes + 4);
  1175.         immediate_quit--;
  1176.         if (bytesRead < 0) {
  1177.             MARK_DISCONNECTED;
  1178.             perror_with_name("RecvReply: Error reading socket (2).");
  1179.         }
  1180.         /*
  1181.          * Check message number before size because it could be
  1182.          * an old packet.
  1183.          */
  1184.         if (*(int *)replyBuffer != msgNum) {
  1185. #ifdef KDBX
  1186.             printf("RecvReply: Old message number = %d, expecting %d\n",
  1187.                 *(int *)replyBuffer - FIRST_MSG, 
  1188.                 msgNum - FIRST_MSG);
  1189. #else
  1190.             printf("RecvReply: Old message number = %d, expecting %d\n",
  1191.                 *(int *)replyBuffer, msgNum);
  1192. #endif
  1193.             fflush(stdout);
  1194.             resendRequest = 1;
  1195.             continue;
  1196.         }
  1197.         if (bytesRead != numBytes + 4) {
  1198.             printf("RecvReply: Short read (2): op=%d exp=%d read=%d",
  1199.                 opcode, numBytes + 4, bytesRead);
  1200.         }
  1201.         if (*(int *)replyBuffer != msgNum) {
  1202.             continue;
  1203.         }
  1204.         bcopy(replyBuffer + 4, destAddr, numBytes);
  1205.         return;
  1206.         }
  1207.     } while (1);
  1208.     }
  1209. }
  1210.  
  1211.  
  1212. /*
  1213.  * ----------------------------------------------------------------------------
  1214.  *
  1215.  *  WaitForKernel --
  1216.  *
  1217.  *      Wait for the kernel to send us a message to indicate that it is waiting
  1218.  *    to be debugged.
  1219.  *
  1220.  * Results:
  1221.  *     None.
  1222.  *
  1223.  * Side effects:
  1224.  *     None.
  1225.  * ----------------------------------------------------------------------------
  1226.  */
  1227. static void
  1228. WaitForKernel()
  1229. {
  1230.     int    dummy;
  1231.  
  1232.     RecvReply(DBG_CONTINUE, 4, &dummy, NULL, 0);
  1233. }
  1234.  
  1235.  
  1236. /*
  1237.  * ----------------------------------------------------------------------------
  1238.  *
  1239.  * BlockInCache --
  1240.  *
  1241.  *     See if the given block at the given address is in the cache.
  1242.  *
  1243.  * Results:
  1244.  *     1 if found block in cache, 0 if didn't.
  1245.  *
  1246.  * Side effects:
  1247.  *     None.
  1248.  */
  1249. static int
  1250. BlockInCache(blockNum, addr)
  1251.     int        blockNum;
  1252.     char    *addr;
  1253. {
  1254.     blockNum = blockNum & CACHE_BLOCK_MASK;
  1255.     return((int) (cacheInfo[blockNum].version == currentVersion &&
  1256.        (unsigned int) cacheInfo[blockNum].realAddr == 
  1257.             ((unsigned int) (addr) & ~CACHE_BLOCK_OFFSET_MASK)));
  1258. }
  1259.  
  1260.  
  1261. /*
  1262.  * ----------------------------------------------------------------------------
  1263.  *
  1264.  * FetchBlock --
  1265.  *
  1266.  *     Fetch the given data block from the cache or the kernel if necessary.
  1267.  *
  1268.  * Results:
  1269.  *     1 if could fetch block into cache, 0 if couldn't.
  1270.  *
  1271.  * Side effects:
  1272.  *     Data cache modified.
  1273.  *
  1274.  * ----------------------------------------------------------------------------
  1275.  */
  1276. static int
  1277. FetchBlock(blockNum, srcAddr, opcode)
  1278.     int        blockNum;
  1279.     char    *srcAddr;
  1280.     Dbg_Opcode    opcode;
  1281. {
  1282.     int    successfulRead;
  1283.  
  1284.     blockNum = blockNum & CACHE_BLOCK_MASK;
  1285.     srcAddr = (char *) ((unsigned int) (srcAddr) & ~CACHE_BLOCK_OFFSET_MASK);
  1286.  
  1287.     if (BlockInCache(blockNum, srcAddr)) {
  1288.     return(1);
  1289.     }
  1290.     msg.opcode = opcode;
  1291.     msg.data.readMem.address = (int) srcAddr;
  1292.     msg.data.readMem.numBytes = cacheBlockSize;
  1293.     SendRequest(sizeof(msg.opcode) + sizeof(Dbg_ReadMem), 1);
  1294.     RecvReply(opcode, cacheBlockSize, 
  1295.         &dataCache[(unsigned int) (srcAddr) & CACHE_OFFSET_MASK],
  1296.         &successfulRead, 1);
  1297.     if (successfulRead) {
  1298.     cacheInfo[blockNum].version = currentVersion;
  1299.     cacheInfo[blockNum].realAddr = srcAddr;
  1300.     }
  1301.     return(successfulRead);
  1302. }
  1303.  
  1304.  
  1305.  
  1306. /*
  1307.  * ----------------------------------------------------------------------------
  1308.  *
  1309.  * Kdbx_Trace --
  1310.  *
  1311.  *     Write the trace command over to the kernel.  
  1312.  *
  1313.  * Results:
  1314.  *     None.
  1315.  *
  1316.  * Side effects:
  1317.  *     None.
  1318.  *
  1319.  * ----------------------------------------------------------------------------
  1320.  */
  1321. int 
  1322. Kdbx_Trace(opcode, srcAddr, destAddr, numBytes)
  1323.     Dbg_Opcode    opcode;        /* Which command */
  1324.     char    *srcAddr;    /* Where to read data from */
  1325.     char    *destAddr;    /* Where to write data to */
  1326.     int        numBytes;    /* The number of bytes to read or write */
  1327. {
  1328.     int            (*intrHandler)();
  1329.     int            i;
  1330.     int            retVal = 0;
  1331.     if (!initialized) {
  1332.     int    moreData;
  1333.     /*
  1334.      * Setup the cache and initiate a conversation with the other kernel.
  1335.      */
  1336.     if (cacheBlockSize == -1) {
  1337.          {
  1338.         cacheBlockSize = 256;
  1339.         cacheBlockShift = 8;
  1340.         }
  1341.     }
  1342.     dataCache = (char *) malloc(cacheSize);
  1343.     cacheInfo = (CacheInfo *) malloc(NUM_CACHE_BLOCKS * sizeof(CacheInfo));
  1344.     for (i = 0; i < NUM_CACHE_BLOCKS; i++) {
  1345.         cacheInfo[i].version = 0;
  1346.     }
  1347.     StartDebugger();
  1348.     /*
  1349.      * Dump the system log by faking a call command.
  1350.      */
  1351.     printf("Dumping system log ...\n");
  1352.     fflush(stdout);
  1353.     msg.opcode = (short)DBG_BEGIN_CALL;
  1354.     SendRequest(sizeof(msg.opcode), 1);
  1355.     msg.opcode = (short)DBG_END_CALL;
  1356.     do {
  1357.         SendRequest(sizeof(msg.opcode), 1);
  1358.         RecvReply(msg.opcode, 0, NULL, &moreData, 1);
  1359.     } while (moreData);
  1360.     initialized = 1;
  1361.     }
  1362.  
  1363.  
  1364.     if (opcode == DBG_DATA_READ || opcode == DBG_INST_READ) {
  1365.     int            firstBlock;
  1366.     int            lastBlock;
  1367.     unsigned    int    cacheOffset;
  1368.     int            toRead;
  1369.  
  1370.     /*
  1371.      * Read using the cache.
  1372.      */
  1373.     firstBlock = GET_CACHE_BLOCK(srcAddr); 
  1374.     lastBlock = GET_CACHE_BLOCK(srcAddr + numBytes - 1);
  1375.     for (i = firstBlock; i <= lastBlock; i++) {
  1376.         cacheOffset = ((unsigned int) srcAddr) & CACHE_OFFSET_MASK;
  1377.         if (i == lastBlock) {
  1378.         toRead = numBytes;
  1379.         } else if (i == firstBlock) {
  1380.         toRead = cacheBlockSize - 
  1381.                 (cacheOffset & CACHE_BLOCK_OFFSET_MASK);
  1382.         } else {
  1383.         toRead = cacheBlockSize;
  1384.         }
  1385.         if (!FetchBlock(i, srcAddr, opcode)) {
  1386.         return EIO;
  1387.         }
  1388.         bcopy(&dataCache[cacheOffset], destAddr, toRead);
  1389.         srcAddr += toRead;
  1390.         destAddr += toRead;
  1391.         numBytes -= toRead;
  1392.     }
  1393.     return(0);
  1394.     }
  1395.  
  1396.     if (opcode == DBG_DATA_WRITE || opcode == DBG_INST_WRITE) {
  1397.     int    firstBlock;
  1398.     int    lastBlock;
  1399.     int    cacheOffset;
  1400.     int    toWrite;
  1401.     char    *tSrcAddr;
  1402.     char    *tDestAddr;
  1403.     int    tNumBytes;
  1404.  
  1405.     /*
  1406.      * If the block that is being fetched is in the cache then write the
  1407.      * data there first before sending it over to the kernel.
  1408.      */
  1409.     tSrcAddr = srcAddr;
  1410.     tDestAddr = destAddr;
  1411.     tNumBytes = numBytes;
  1412.  
  1413.     firstBlock = GET_CACHE_BLOCK(destAddr); 
  1414.     lastBlock = GET_CACHE_BLOCK(destAddr + numBytes - 1);
  1415.     for (i = firstBlock; i <= lastBlock; i++) {
  1416.         cacheOffset = ((int) tDestAddr) & CACHE_OFFSET_MASK;
  1417.         if (i == lastBlock) {
  1418.         toWrite = tNumBytes;
  1419.         } else if (i == firstBlock) {
  1420.         toWrite = cacheBlockSize - 
  1421.                 (cacheOffset & CACHE_BLOCK_OFFSET_MASK);
  1422.         } else {
  1423.         toWrite = cacheBlockSize;
  1424.         }
  1425.         if (BlockInCache(i, tDestAddr)) {
  1426.         bcopy(tSrcAddr, &dataCache[cacheOffset], tNumBytes);
  1427.         }
  1428.         tSrcAddr += toWrite;
  1429.         tDestAddr += toWrite;
  1430.         tNumBytes -= toWrite;
  1431.     }
  1432.     }
  1433.  
  1434.     msg.opcode = (short) opcode;
  1435.  
  1436.     /*
  1437.      * Do the rest of the work for the desired operation.
  1438.      */
  1439.  
  1440.     switch (opcode) {
  1441.  
  1442.     /*
  1443.      * For these operations the desired data is read from the other
  1444.      * kernel and stored at destAddr.
  1445.      */
  1446.     case DBG_READ_ALL_REGS:
  1447.     case DBG_GET_STOP_INFO:
  1448.         SendRequest(sizeof(msg.opcode), 1);
  1449.         RecvReply(opcode, numBytes, destAddr, NULL, 1);
  1450.         break;
  1451.  
  1452.     /*
  1453.      * For this operation the desired data is read from srcAddr
  1454.      * and written to the other kernel.
  1455.      */
  1456.     case DBG_SET_PID:
  1457.         msg.data.pid = *(int *)srcAddr;
  1458.         SendRequest(sizeof(msg.opcode) + sizeof(msg.data.pid), 1);
  1459.         break;
  1460.  
  1461.     /*
  1462.      * When writing a general purpose register first the address to write
  1463.      * that is stored in destAddr must be given to the other kernel.
  1464.      * Then the data itself which is stored at srcAddr can be written over.
  1465.      */
  1466.     case DBG_WRITE_REG:
  1467.         msg.data.writeReg.regNum = (int) destAddr;
  1468.         msg.data.writeReg.regVal = *(int *) srcAddr;
  1469.         SendRequest(sizeof(msg.opcode) + sizeof(Dbg_WriteReg), 1);
  1470.         break;
  1471.  
  1472.     /*
  1473.      * When writing to the kernels instruction or data space first the
  1474.      * address of where to write to (destAddr) and then the number of
  1475.      * bytes to write (numBytes) must be sent over.  Finally all of
  1476.      * the data is read from srcAddr and written over.
  1477.      */
  1478.  
  1479.     case DBG_INST_WRITE:
  1480.     case DBG_DATA_WRITE: {
  1481.         char    writeStatus;
  1482.  
  1483.         msg.data.writeMem.address = (int) destAddr;
  1484.         msg.data.writeMem.numBytes = numBytes;
  1485.         bcopy(srcAddr, msg.data.writeMem.buffer, numBytes);
  1486.         SendRequest(sizeof(msg.opcode) + 2 * sizeof(int) + numBytes, 1);
  1487.         RecvReply(opcode, 1, &writeStatus, NULL, 1);
  1488.         if (writeStatus == 0) {
  1489.         retVal = EIO;
  1490.         fprintf(stderr, "ERROR: invalid write address 0x%x\n",destAddr);
  1491.         } 
  1492.         break;
  1493.     }
  1494.     case DBG_DIVERT_SYSLOG:
  1495.         msg.data.syslogCmd = (Dbg_SyslogCmd)srcAddr;
  1496.         SendRequest(sizeof(msg.opcode) + sizeof(Dbg_SyslogCmd), 1);
  1497.         break;
  1498.     case DBG_BEGIN_CALL:
  1499.         SendRequest(sizeof(msg.opcode), 1);
  1500.         break;
  1501.     case DBG_END_CALL: {
  1502.         Boolean    moreData;
  1503.         do {
  1504.         SendRequest(sizeof(msg.opcode), 1);
  1505.         RecvReply(opcode, 0, NULL, &moreData, 1);
  1506.         } while (moreData);
  1507.         break;
  1508.     }
  1509.  
  1510.     case DBG_DETACH: {
  1511.         msg.opcode = (short) DBG_DIVERT_SYSLOG;
  1512.         msg.data.syslogCmd = DBG_SYSLOG_TO_ORIG;
  1513.         SendRequest(sizeof(msg.opcode) + sizeof(Dbg_SyslogCmd), 1);
  1514.  
  1515.         msg.opcode = (short) DBG_DETACH;
  1516.         msg.data.pc = *(int *) srcAddr;
  1517.         SendRequest(sizeof(msg.opcode) + sizeof(msg.data.pc), 1);
  1518.         break;
  1519.     }
  1520.  
  1521.     case DBG_CONTINUE:
  1522.     case DBG_SINGLESTEP:
  1523.         SendRequest(sizeof(msg.opcode) + sizeof(msg.data.pc), 1);
  1524.         currentVersion++;
  1525.         WaitForKernel();
  1526.         break;
  1527.  
  1528.     case DBG_CALL_FUNCTION: {
  1529.         int        returnValue;
  1530.  
  1531.         msg.data.callFunc.address = (int) destAddr;
  1532.         msg.data.callFunc.numBytes = numBytes;
  1533.         bcopy(srcAddr, msg.data.callFunc.buffer, numBytes);
  1534.         SendRequest(sizeof(msg.opcode) + 2 * sizeof(int) + numBytes, 1);
  1535.         RecvReply(opcode, sizeof(returnValue), &returnValue, NULL, 1);
  1536.         return (returnValue);
  1537.     }
  1538.     case DBG_REBOOT: {
  1539.         msg.data.reboot.stringLength = numBytes;
  1540.         bcopy(srcAddr, msg.data.reboot.string, numBytes);
  1541.         SendRequest(sizeof(msg.opcode) + sizeof(int) + numBytes, 1);
  1542.         return (0);
  1543.     }
  1544.     case DBG_GET_VERSION_STRING: {
  1545.         SendRequest(sizeof(msg.opcode), 1);
  1546.         RecvReply(opcode,numBytes , destAddr, NULL, 1);
  1547.         return (0);
  1548.     }
  1549.     default:
  1550.         printf("Unknown opcode %d\n", opcode);
  1551.         return(-1);
  1552.     }
  1553.     return(retVal);
  1554. }
  1555.  
  1556.  
  1557.  
  1558.  
  1559.  
  1560.  
  1561.  
  1562.  
  1563.  
  1564. @
  1565.  
  1566.  
  1567. 1.1
  1568. log
  1569. @Initial revision
  1570. @
  1571. text
  1572. @d333 6
  1573. d347 1
  1574. a347 2
  1575.   
  1576.   text_size = text_end - text_start;
  1577. d349 5
  1578. d764 1
  1579. a764 1
  1580.     0, 0, /* insert_breakpoint, remove_breakpoint, */ 
  1581. @
  1582.  
  1583.  
  1584. 1.1.1.1
  1585. log
  1586. @serial line support (doesn't work correctly)
  1587. @
  1588. text
  1589. @a31 1
  1590. #include <kernel/dbg.h>
  1591. a32 4
  1592. #ifndef DBG_ACK_SIZE
  1593. #define DBG_ACK_SIZE 1
  1594. #endif
  1595.  
  1596. d67 1
  1597. a67 1
  1598.     if (!hostName && !serialPort) error("No machine attached.");
  1599. a123 4
  1600. static int    serialDebug = 0;
  1601. static int    kernChannel = 0;
  1602. static char    *serialPort = NULL;
  1603.  
  1604. d251 4
  1605. a254 11
  1606.   if (*name == '/') {
  1607.       serialDebug = 1;
  1608.       serialPort = savestring(name,strlen(name));
  1609.       if (from_tty) {
  1610.       printf("Remote debugging using serial device %s\n", name);
  1611.       }
  1612.   } else {
  1613.       hostName = savestring(name,strlen(name));
  1614.       if (from_tty)
  1615.     printf ("Remote debugging using %s\n", name);
  1616.   }
  1617. d794 5
  1618. a893 48
  1619.     if (serialDebug) {
  1620.     struct         sgttyb     modes;
  1621.     int        i;
  1622.     char        buffer[32];
  1623.  
  1624.     kernChannel = open(serialPort, 2);
  1625.     if (kernChannel < 0) {
  1626.         perror_with_name("Could not open serial line\n");
  1627.         exit(1);
  1628.     }
  1629.  
  1630.     /*
  1631.      * Flush the line.
  1632.      */
  1633.     i = 0;
  1634.     ioctl(kernChannel, TIOCFLUSH, &i);
  1635.  
  1636.     /*
  1637.      * Turn off parity and echoing.
  1638.      */
  1639.     if (ioctl(kernChannel,TIOCGETP,&modes) < 0) {
  1640.         perror("ioctl get modes");
  1641.         abort();
  1642.     }
  1643.     printf("ispeed = %d, ospeed = %d\n", modes.sg_ispeed, modes.sg_ospeed);
  1644.     modes.sg_flags |= RAW|ANYP;
  1645.     modes.sg_flags &= ~ECHO;
  1646.     if (ioctl(kernChannel,TIOCSETP,&modes) < 0) {
  1647.         perror("ioctl put modes");
  1648.         abort();
  1649.     }
  1650.  
  1651.     /*
  1652.      * Send the other half a magic sequence of characters that it is
  1653.      * waiting for, and wait for the response. 
  1654.      */
  1655.     WriteSerial("Hey", 3, 1);
  1656.     sleep(5);
  1657.     ReadSerial(buffer, 5);
  1658.     buffer[5] = '\0';
  1659.     if (strcmp(buffer, "Aloha")) {
  1660.         printf("Remote gave wrong secret password: \"%s\"\n", buffer);
  1661.         close(kernChannel);
  1662.     } else {
  1663.         printf("Got the secret password\n");
  1664.     }
  1665.     } else {
  1666.  
  1667. a897 1
  1668.     }
  1669. d920 1
  1670. a920 24
  1671.     if (serialDebug) {
  1672.     /*
  1673.      * First send the opcode.
  1674.      */
  1675.     printf("Sending opcode\n");
  1676.     WriteSerial(&msg.opcode, sizeof(msg.opcode), 1);
  1677.     if ((Dbg_Opcode) msg.opcode != DBG_DATA_WRITE && 
  1678.         (Dbg_Opcode) msg.opcode != DBG_INST_WRITE) {
  1679.         /*
  1680.          * If not a write send the rest.
  1681.          */
  1682.         printf("Sending rest of command\n");
  1683.         WriteSerial(&msg.data, numBytes - sizeof(msg.opcode), 1);
  1684.     } else {
  1685.         /*
  1686.          * Send the size and numBytes first and then the data.
  1687.          */
  1688.         printf("Sending addr and numBytes\n");
  1689.         WriteSerial(&msg.data.writeMem, 2 * sizeof(int), 1);
  1690.         printf("Sending data\n");
  1691.         WriteSerial(msg.data.writeMem.buffer,
  1692.                    msg.data.writeMem.numBytes, 1);
  1693.     }
  1694.     } else {
  1695. a975 1
  1696.  
  1697. d981 1
  1698. a981 31
  1699.     if (serialDebug) {
  1700.     if (opcode == DBG_DATA_READ || opcode == DBG_INST_READ) {
  1701.         ReadSerial(&status, sizeof(status));
  1702.         if (status == 0) {
  1703.         *readStatusPtr = 0;
  1704.         return;
  1705.         }
  1706.         *readStatusPtr = 1;
  1707.         ReadSerial(destAddr, numBytes);
  1708.     } else if (opcode == DBG_END_CALL) {
  1709.         int        length;
  1710.         /*
  1711.          * End call returns the length and then the data.  First read
  1712.          * then length, then the data, then dump the log.
  1713.          */
  1714.         ReadSerial(&length, sizeof(length));
  1715.         printf("Remote says to read %d bytes\n", length);
  1716.         if (length > 1024) {
  1717.         abort();
  1718.         }
  1719.         if (length == 0) {
  1720.         *readStatusPtr = 0;
  1721.         } else {
  1722.         ReadSerial(replyBuffer, length);
  1723.         write(1, replyBuffer, length);
  1724.         *readStatusPtr = 1;
  1725.         }
  1726.     } else {
  1727.         ReadSerial(destAddr, numBytes);
  1728.     }
  1729.     } else {
  1730. a1186 8
  1731.     if (serialDebug) {
  1732.     unsigned char ch;
  1733.  
  1734.     if (read(kernChannel, &ch, 1) != 1) {
  1735.         fprintf(stderr,"Read from kernChannel (2)");
  1736.         abort();
  1737.     }
  1738.     } else {
  1739. a1189 1
  1740.     }
  1741. a1260 142
  1742.  
  1743. /*
  1744.  * ----------------------------------------------------------------------------
  1745.  *
  1746.  * ReadSerial --
  1747.  *
  1748.  *     Read the given number of bytes over from the kernel on the serial line. 
  1749.  *
  1750.  * Results:
  1751.  *     None.
  1752.  *
  1753.  * Side effects:
  1754.  *     None.
  1755.  *
  1756.  * ----------------------------------------------------------------------------
  1757.  */
  1758. static int
  1759. ReadSerial(buf, numBytes)
  1760.     char *buf;        /* Buffer to read into */
  1761.     int  numBytes;    /* Number of bytes to read */
  1762. {
  1763.     int readSoFar;    /* The total number of bytes that we have read */
  1764.     int bytesRead;    /* The number of bytes read in the last read */
  1765.     int ackCount;    /* The number of bytes that have been acknowledgment */
  1766.  
  1767.     ackCount = 0;
  1768.     readSoFar = 0;
  1769.     printf("ReadSerial: reading %d bytes\n", numBytes);
  1770.     while (readSoFar < numBytes) {
  1771.     bytesRead = read(kernChannel, &buf[readSoFar], numBytes - readSoFar);
  1772.     if (bytesRead < 0) {
  1773.         MARK_DISCONNECTED;
  1774.         perror_with_name("ReadBytes: Couldn't read from the kernel channel\n");
  1775.         return(-1);
  1776.     }
  1777.  
  1778.     readSoFar += bytesRead;
  1779.     if (readSoFar - ackCount == DBG_ACK_SIZE) {
  1780.         printf("Acking\n");
  1781.         if (write(kernChannel, &readSoFar, 1) < 1) {
  1782.         MARK_DISCONNECTED;
  1783.         perror_with_name("ReadBytes: Couldn't write to kernel channel\n");
  1784.         return(-1);
  1785.         }
  1786.         printf("Ack done\n");
  1787.         ackCount += DBG_ACK_SIZE;
  1788.     }
  1789.     }
  1790.  
  1791.     return(0);
  1792. }
  1793.  
  1794. /*
  1795.  * ----------------------------------------------------------------------------
  1796.  *
  1797.  * WriteSerial --
  1798.  *
  1799.  *     Write the bytes over to the kernel across the serial line.  Every
  1800.  *     DBG_ACK_SIZE character that we write is acknowledged by a character
  1801.  *     that is sent by the other kernel.  This is so we don't get ahead
  1802.  *     of the other kernel.
  1803.  *
  1804.  * Results:
  1805.  *     None.
  1806.  *
  1807.  * Side effects:
  1808.  *     None.
  1809.  *
  1810.  * ----------------------------------------------------------------------------
  1811.  */
  1812. static int
  1813. WriteSerial(buf, numBytes, ack)
  1814.     char *buf;        /* Pointer to buffer to write */
  1815.     int  numBytes;    /* Number of bytes to write */
  1816.     Boolean    ack;    /* Acknowledge when done and every 3 characters. */
  1817. {
  1818.     unsigned char input;
  1819.     int    i;
  1820.     int    toWrite;
  1821.     int    j;
  1822.     int    delay = 4000000;
  1823.  
  1824.     if (numBytes == 0) {
  1825.     return(0);
  1826.     }
  1827.     printf("WriteSerial: writing %d bytes, ack = %d\n", numBytes, DBG_ACK_SIZE);
  1828.     if (!ack) {
  1829. #ifdef NOTDEF
  1830.     for (i = 0; i < numBytes; i++) {
  1831.         if (write(kernChannel, &buf[i], 1) < 1) {
  1832.         MARK_DISCONNECTED;
  1833.         perror_with_name(
  1834.             "WriteBytes: Couldn't write to the kernel channel\n");
  1835.         return(-1);
  1836.         }
  1837.         for (j = 0; j < delay; j++);
  1838.     }
  1839. #endif  /* NOTDEF */
  1840.  
  1841.     if (write(kernChannel, buf, numBytes) < numBytes) {
  1842.         MARK_DISCONNECTED;
  1843.         perror_with_name("WriteBytes: Couldn't write to the kernel channel\n");
  1844.         return(-1);
  1845.     }
  1846.     return(0);
  1847.     }
  1848.  
  1849.     do {
  1850.     if (numBytes > DBG_ACK_SIZE) {
  1851.         toWrite = DBG_ACK_SIZE;
  1852.     } else {
  1853.         toWrite = numBytes;
  1854.     }
  1855. #ifdef NOTDEF
  1856.     for (i = 0; i < toWrite; i++) {
  1857.         if (write(kernChannel, &buf[i], 1) < 1) {
  1858.         MARK_DISCONNECTED;
  1859.         perror_with_name(
  1860.             "WriteBytes: Couldn't write to the kernel channel\n");
  1861.         return(-1);
  1862.         }
  1863.         for (j = 0; j < delay; j++);
  1864.     }
  1865. #endif  /* NOTDEF */
  1866.  
  1867.     printf("Writing %d bytes to channel\n", toWrite);
  1868.     if (write(kernChannel, buf, toWrite) < toWrite) {
  1869.         MARK_DISCONNECTED;
  1870.         perror_with_name("WriteBytes: Couldn't write to the kernel channel\n");
  1871.         return(-1);
  1872.     }
  1873.     buf += toWrite;
  1874.     numBytes -= toWrite;
  1875.  
  1876.     printf("Waiting for ack\n");
  1877.     if (read(kernChannel, &input, 1) < 1) {
  1878.         MARK_DISCONNECTED;
  1879.         perror_with_name("WriteBytes: Couldn't read from the kernel channel\n");
  1880.         return(-1);
  1881.     }
  1882.     printf("Got ack\n");
  1883.     } while (numBytes > 0);
  1884. a1261 3
  1885.     return(0);
  1886. }
  1887.  
  1888. d1294 1
  1889. a1294 4
  1890.         if (serialDebug) {
  1891.         cacheBlockSize = 32;
  1892.         cacheBlockShift = 5;
  1893.         } else {
  1894. @
  1895.